const checkModel = require('../modules/checktimemodules')
const leaveModel = require('../modules/leavemodules')
const overTimeModel = require('../modules/overtimemodules')
const forgetModel = require('../modules/forgetmodules')
const moment = require('moment');
const xlsx= require ('node-xlsx');
const urlencode = require('urlencode');
const log= require('../middleware/log4j')
const dateConfig=require('../config/dateconfig')
const excelConfig=require('../config/excelconfig')
const fs=require('fs')
const path =require('path');
class checkTimeController {
    
    /**
     * 根据登录名获取打卡时间
     * @param ctx
     * @returns {Promise.<void>}
     */
    static async getCheckTimeByName(ctx) {
        //console.log(ctx.request.body);
        let req = ctx.request.body;
        let start = req.start;
        let end = req.end;
        let name = req.loginname;
        //console.log(start);
        if (name) {
            try {
                //获取打卡记录
                let data = await checkModel.getUserByLoginName(name,start,end);
                // console.log(data[0].dataValues);
                let result=new Array();
                for(let i=0;i<data.length;i++){
                    let o=data[i].dataValues;
                    let v=new Object();
                    //v.DEFAULTDEPTID=o.DEFAULTDEPTID;
                    //v.verifycode=o.verifycode;
                    v.title=moment(o.CHECKTIME).format('YYYY-MM-DD HH:mm:ss');//时分.format('YYYY-MM-DD HH:mm:ss')
                    v.checktime=o.CHECKTIME;//用来做对比
                    v.start=moment(o.CHECKTIME).format('YYYY-MM-DD');//日期
                    //v.color="red";
                    if(moment(o.CHECKTIME).isBetween(`${dateConfig.summer.startDate}`,`${dateConfig.summer.endtDate}`)){
                        //夏令时
                        if(moment(o.CHECKTIME).isBetween(`${v.start} ${dateConfig.summer.startTime}`,`${v.start} ${dateConfig.summer.endTime}`))
                        {
                            v.textColor="red";
                        }else if(moment(o.CHECKTIME).isAfter(`${v.start} ${dateConfig.summer.overTime}`)){
                            v.textColor="green";
                        }
                        else{
                            v.textColor="black";
                        }       
                    }else{
                        //冬令时
                        if(moment(o.CHECKTIME).isBetween(`${v.start} ${dateConfig.winter.startTime}`,`${v.start} ${dateConfig.winter.endTime}`))
                        {
                            v.textColor="red";
                        }else if(moment(o.CHECKTIME).isAfter(`${v.start} ${dateConfig.winter.overTime}`)){
                            v.textColor="green";
                        }
                        else{
                            v.textColor="black";
                        }
                    }
                    v.allDay=true;
                    result.push(v);
                }
                //获取加班记录
                let overresult=new Array();
                let overdata=await overTimeModel.getOvertimeByLoginName(name,start,end);
                for(let i=0;i<overdata.length;i++){
                    let odate=overdata[i].dataValues;
                    let od=new Object();
                    od.start=odate.startTIME;
                    od.end=odate.endTIME;
                    od.category=odate.category;
                    od.title=`加:${odate.category}从${moment(odate.startTIME).format('MM-DD HH:mm')}至${moment(odate.endTIME).format('MM-DD HH:mm')}`;
                    overresult.push(od);
                    od.textColor="#2d58cc";
                    result.push(od);
                }
                //获取忘打卡记录
                let forgetresult=new Array();
                let forgetdata=await forgetModel.getForgetsByLoginName(name,start,end);
                for(let i=0;i<forgetdata.length;i++){
                    let fdata=forgetdata[i].dataValues;
                    let fd=new Object();
                    fd.title=`忘:${fdata.sector}-${moment(fdata.clockdate).format('YYYY-MM-DD HH:mm:ss')}`;
                    fd.checktime=fdata.clockdate;
                    fd.start=moment(fdata.clockdate).format('YYYY-MM-DD');//日期
                    fd.textColor="#636363";
                    forgetresult.push(fd);
                    result.push(fd);
                }
                //获取请假记录
                let leavedata = await leaveModel.getLeaveByLoginName(name,start,end);
                let leaveresult=new Array();
                for(let i=0;i<leavedata.length;i++){
                    let ld=leavedata[i].dataValues;
                    let lv=new Object();
                    lv.start=ld.startTIME;//日期ld.startTime;
                    lv.end=ld.endTIME;
                    lv.title=ld.category;
                    leaveresult.push(lv);
                }
                let startarray=new Array();
                let endarray=new Array();
                /**请假开始时间有效 false 显示无效*/
                let sflag=false;
                /**请假结束时间有效*/
                let eflag=false;
                /**上班开始时间默认夏季*/
                let workstartTime=dateConfig.summer.startTime;
                /**上班结束时间默认夏季*/
                let workendTime=dateConfig.summer.endTime;
                /**午休开始时间 */
                let lunchstartTime=dateConfig.summer.lunchtime_startTime;
                /**午休结束时间 */
                let lunchendTime=dateConfig.summer.lunchtime_endTime;
                /**午休时长 */
                let toalTime=dateConfig.summer.toalTime;
                /**加班开始时刻 */
                let overstart=dateConfig.summer.overTime;
                /**由请假类别区分出的阈值 */
                let threshold=dateConfig.threshold.default;
                /**根据季节初始化上班时间、下班时间、午休时长、午休开始时间、午休结束时间 */
                function judgeTime(time){
                    if(moment(time).isBetween(`${dateConfig.summer.startDate}`,`${dateConfig.summer.endtDate}`)){
                        workstartTime=dateConfig.summer.startTime;
                        workendTime=dateConfig.summer.endTime;
                        toalTime=dateConfig.summer.lunchtime_toalTime;
                        lunchstartTime=dateConfig.summer.lunchtime_startTime;
                        lunchendTime=dateConfig.summer.lunchtime_endTime;
                        overstart=dateConfig.summer.overTime;
                    }else{
                        workstartTime=dateConfig.winter.startTime;
                        workendTime=dateConfig.winter.endTime;
                        toalTime=dateConfig.winter.lunchtime_toalTime;
                        lunchstartTime=dateConfig.winter.lunchtime_startTime;
                        lunchendTime=dateConfig.winter.lunchtime_endTime;
                        overstart=dateConfig.winter.overTime;
                    } 
                }
                // 处理请假单部分
                for(let l=0;l<leaveresult.length;l++){
                    sflag=false;
                    eflag=false;
                    //清空数组；数组存放请假开始/结束同一天的打卡记录
                    startarray.splice(0,startarray.length);
                    endarray.splice(0,endarray.length)
                    for(let m=0;m<result.length;m++){
                       
                        if(moment(leaveresult[l].start).isSame(result[m].checktime,'day')){
                            //判断打卡时间和请假开始时间是同一天的打卡时间
                            startarray.push(result[m]);
                        }
                        if(moment(leaveresult[l].end).isSame(result[m].checktime,'day')){
                            //判断打卡时间和请假结束时间是同一天的打卡时间
                            endarray.push(result[m]);
                        }
                    }
                    /**根据季节初始化上班时间、下班时间、午休时长、午休开始时间、午休结束时间 */
                    /**if(moment(leaveresult[l].start).isBetween(`${dateConfig.summer.startDate}`,`${dateConfig.summer.endtDate}`)){
                        workstartTime=dateConfig.summer.startTime;
                        workendTime=dateConfig.summer.endTime;
                        toalTime=dateConfig.summer.toalTime;
                        lunchstartTime=dateConfig.summer.lunchtime_startTime;
                        lunchendTime=dateConfig.summer.lunchtime_endTime;
                    }else{
                        workstartTime=dateConfig.winter.startTime;
                        workendTime=dateConfig.winter.endTime;
                        toalTime=dateConfig.winter.toalTime;
                        lunchstartTime=dateConfig.winter.lunchtime_startTime;
                        lunchendTime=dateConfig.winter.lunchtime_endTime;
                    }*/
                    judgeTime(leaveresult[l].start);
                    //根据请假类别初始化阈值
                    switch(leaveresult[l].title){
                        case '外出公干':
                            threshold=dateConfig.threshold.business;
                            break;
                        default:
                            threshold=dateConfig.threshold.default;
                            break;
                    }
                    //console.log(moment(leaveresult[l].start).format('YYYY-MM-DD HH:mm:ss'));
                    //是否有在请假开始时间之后的打卡记录
                    for(let s=0;s<startarray.length;s++){
                        //1.上班开始时间之后的请假需要验证在请假开始时或之后是否有打卡记录
                        //2.上班开始时间之前的请假需不需要验证在请假开始时或之后是否有打卡记录
                        if(moment(leaveresult[l].start).isSameOrBefore(`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${workstartTime}`,'second')){
                            //开始时间在上班时间之前
                            sflag=true;
                            break;
                        } else if(moment(startarray[s].checktime).isBetween(moment(leaveresult[l].start).format('YYYY-MM-DD HH:mm:ss'),`${moment(leaveresult[l].start).add(threshold,'minutes').format('YYYY-MM-DD HH:mm:ss')}`,'second','[]')){
                           //在请假开始时间之后15分钟内存在一条打卡记录
                            sflag=true;
                            break;
                        }else if(moment(leaveresult[l].start).isBetween(`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${lunchstartTime}`,`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${lunchendTime}`,'second','[]')){
                            //请假开始时间在午休区间且在午休时间存在一条打卡记录
                            if(moment(startarray[s].checktime).isBetween(`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${lunchstartTime}`,`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${lunchendTime}`,'second','[]')){
                                sflag=true;
                                break;
                            }
                        }
                    }
                    //一种特殊情况 没有打卡记录 请假单开始在上班或之前
                    if(moment(leaveresult[l].start).isSameOrBefore(`${moment(leaveresult[l].start).format('YYYY-MM-DD')} ${workstartTime}`,'second')){
                        sflag=true;
                    }
                    /**根据季节初始化上班时间、下班时间、午休时长、午休开始时间、午休结束时间 */
                    judgeTime(leaveresult[l].end);
                    /**if(moment(leaveresult[l].end).isBetween(`${dateConfig.summer.startDate}`,`${dateConfig.summer.endtDate}`)){
                        workstartTime=dateConfig.summer.startTime;
                        workendTime=dateConfig.summer.endTime;
                        toalTime=dateConfig.summer.toalTime;
                        lunchstartTime=dateConfig.summer.lunchtime_startTime;
                        lunchendTime=dateConfig.summer.lunchtime_endTime;
                    }else{
                        workstartTime=dateConfig.winter.startTime;
                        workendTime=dateConfig.winter.endTime;
                        toalTime=dateConfig.winter.toalTime;
                        lunchstartTime=dateConfig.winter.lunchtime_startTime;
                        lunchendTime=dateConfig.winter.lunchtime_endTime;
                    }*/
                    for(let s=0;s<endarray.length;s++){
                        if(moment(leaveresult[l].end).isSameOrAfter(`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${workendTime}`,'second')){
                            //请假单结束时间在下班时间之后
                            eflag=true;
                            break;
                        } else if(moment(endarray[s].checktime).isBetween(`${moment(leaveresult[l].end).subtract(threshold,'minutes').format('YYYY-MM-DD HH:mm:ss')}`,moment(leaveresult[l].end).format('YYYY-MM-DD HH:mm:ss'),'second','[]')&&(moment(endarray[s].checktime)).isAfter(leaveresult[l].start,'minute')){
                            //请假单结束时间往前15分钟内（阈值）有打卡记录
                            eflag=true;
                            break;
                        }else if(moment(leaveresult[l].end).isBetween(`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${lunchstartTime}`,`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${lunchendTime}`,'second','[]')){
                            //请假单结束时间在午休区间且在午休时间有打卡记录
                            if(moment(endarray[s].checktime).isBetween(`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${lunchstartTime}`,`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${lunchendTime}`,'second','[]')){
                                eflag=true;
                                break;
                            }
                        }
                    }
                    //一种特殊情况 没有打卡记录 请假单结束在下班或之后
                    if(moment(leaveresult[l].end).isSameOrAfter(`${moment(leaveresult[l].end).format('YYYY-MM-DD')} ${workendTime}`,'second')){
                        eflag=true;
                    }
                    //判断请假是否有效
                    if(sflag&&eflag){
                        //有效
                        leaveresult[l].title=`${leaveresult[l].title};${moment(leaveresult[l].start).format('MM-DD HH:mm')}到${moment(leaveresult[l].end).format('MM-DD HH:mm')}`
                        //console.log(JSON.stringify(leaveresult[l])+"  :请假有效！");
                    }else{
                        let str="";
                        if(!sflag){
                          let result=oneBefore(leaveresult[l].start,startarray,lunchstartTime,lunchendTime,toalTime,workstartTime,workendTime);
                          if(result=="erro"){
                             str+="请假单开始之前没有打卡记录" 
                          }else{
                              if(result._milliseconds>0){
                                  str+=`提前${result._milliseconds}分钟`;
                                }
                          }
                        }
                        if(!eflag){
                            let result=oneAfter(leaveresult[l].end,endarray,lunchstartTime,lunchendTime,toalTime,workstartTime,workendTime);
                            if(result=="erro"){
                                str+="请假单结束之前没有打卡记录" 
                            }else{
                                if(result._milliseconds>0){
                                    str+=`晚归${result._milliseconds}分钟`
                                }
                            }
                        }
                        //无效
                        leaveresult[l].title=`${leaveresult[l].title};${moment(leaveresult[l].start).format('MM-DD HH:mm')}到${moment(leaveresult[l].end).format('MM-DD HH:mm')}${str}`
                        //console.log(JSON.stringify(leaveresult[l])+"  :请假无效！");
                        leaveresult[l].className="unable";
                        str=""
                    }
                    leaveresult[l].start=moment(leaveresult[l].start).format('YYYY-MM-DD HH:mm:ss');//日期
                    leaveresult[l].end=moment(leaveresult[l].end).format('YYYY-MM-DD HH:mm:ss');//日期
                    result.push(leaveresult[l]);
                }
                // 处理加班单
                for(let l=0;l<overresult.length;l++){
                    sflag=false;
                    eflag=false;
                    //清空数组；数组存放请假开始/结束同一天的打卡记录
                    startarray.splice(0,startarray.length);
                    endarray.splice(0,endarray.length)
                    for(let m=0;m<result.length;m++){
                       
                        if(moment(overresult[l].start).isSame(result[m].checktime,'day')){
                            //判断打卡时间和请假开始时间是同一天的打卡时间
                            startarray.push(result[m]);
                        }
                        if(moment(overresult[l].end).isSame(result[m].checktime,'day')){
                            //判断打卡时间和请假结束时间是同一天的打卡时间
                            endarray.push(result[m]);
                        }
                    }
                    judgeTime(overresult.start);
                    //工作日加班
                    switch (overresult[l].category) {
                        case '工作日':
                            {
                                
                                
                            }
                            break;
                        case '休息日':
                        
                            break;
                        case '节假日':
                        
                            break;
                        default:
                            break;
                    }
                }
                //console.log(result);
                ctx.response.status = 200;
                ctx.body = {
                    code: 200,
                    msg: '查询成功',
                    data:result
                }

            } catch (err) {
                console.log(err);
                ctx.response.status = 412;
                ctx.body = {
                    code: 412,
                    msg: '查询失败',
                    err
                }
            }
        } else {
            ctx.response.status = 416;
            ctx.body = {
                code: 416,
                msg: '登录名必须传'
            }
        }
    }
    /**上传打卡记录 */
    static async uploadex(ctx){
        let req = ctx.req.body;
        if(ctx.req.file&&ctx.req.file.path){
            var str=ctx.req.file.path;
            req.iconUrl=str.substring(str.indexOf("\\"));
            await initdata(str,ctx);
            // ctx.response.status = 200;
            //     ctx.body = {
            //         code: 200,
            //         msg:'上传成功',
            //         data:''
            //     }
        }
    }
    /**导出报表 */
    static async exportex(ctx){
            let data= await checkModel.getUserByLoginName("郭祖容",'2018-12-29 00:00:00','2019-12-30 00:00:00');
            var arr=new Array();
            for(let i=0;i<data.length;i++){
                arr.push(data[i].dataValues)
            }
            exportExcel(ctx,excelConfig.checktime,arr,"dssd");
            ctx.response.status = 200;
    }
    
}
/**解析考勤Excel文件并且存到数据库 */
async function initdata(str,ctx) {
    try{
        var datajson = xlsx.parse(path.join(__dirname,'../')+`${str}`);
        var firstSheet = datajson[0].data;
        let req=/[0-9]{4}-[0-9]{1,2}-[0-9]{1,2} [0-9]{2}:[0-9]{2}:[0-9]{2}/;
        let bf= await checkModel.getCount();
        //判断上传文件格式是否正确
        if(firstSheet[0][0]!='部门'||firstSheet[0][1]!='姓名'||firstSheet[0][2]!='考勤号码'
           ||firstSheet[0][3]!='日期时间'||firstSheet[0][4]!='机器号'
           ||firstSheet[0][5]!='编号'||firstSheet[0][6]!='比对方式'||firstSheet[0][7]!='卡号'
           ||!req.test(firstSheet[1][3])){
            ctx.response.status = 200;
                ctx.body = {
                    code: 500,
                    msg:'上传失败，文件格式不正确',
                    data:''
                }
                return;
        }
        var insertval = new Array();
        //定义实体类数组
        var checktime = new Array('DEFAULTDEPTID', 'Name', 'PIN', 'CHECKTIME', 'SENSORID', 'SSN', 'verifycode', 'CardNo');
        var res=new Array();
        for (var i = 1; i < firstSheet.length; i++) {
            let cdata = firstSheet[i];
            let odate = new Object();
            for (let j = 0; j < cdata.length; j++) {
                odate[checktime[j]] = cdata[j];
            }
            //console.log(odate);
            if(odate['SSN']==''){log.warn(`异常记录SSN为空：${JSON.stringify(odate)}`)}
            insertval.push(odate)
            if (i % 1000 == 0) {
            let te= await checkModel.createCheckTimes(insertval);
            res.push(te);
            insertval.splice(0, insertval.length)
            }
        }
        await checkModel.createCheckTimes(insertval);
        let af= await checkModel.getCount();
        ctx.response.status = 200;
            ctx.body = {
                code: 200,
                msg:`上传成功,新增${af.count-bf.count}条数据！`,
                data:''
            }
    }catch(err){
       console.log(`上传考勤记录异常：${err}`); 
    }
}
/**导出Excel表格 */
async function exportExcel(ctx,config,listData,exclename){
    let excelConfig = [];
    excelConfig.push(config.map(item => {
        return item.title
    }))
    listData.forEach(list => {
        excelConfig.push(config.map(item => {
            //const value = list[item.column];
            return item.column!='CHECKTIME'?list[item.column]:moment(list[item.column]).format('YYYY-MM-DD HH:mm:ss');
        }))
    })
    //console.log(excelConfig);
    let buffer = xlsx.build([{
        name: exclename,
        data: excelConfig
    }]);
    
    let name = urlencode(exclename + '_' + (+new Date()) + '.xlsx', "utf-8");;
    //console.log(name);
    ctx.set('Content-Type', 'application/vnd.ms-excel;charset=UTF-8'); 
    ctx.set("Content-Disposition", "attachment; filename=" + name);
    // ctx.request.headers['user-agent'] 
    // ctx.setHaeder('Conten-Tyep', 'application/vnd.openxmmlformats:charset:s=utf-8');//设置响应头 
    // ctx.setHaeder('Conten-Disposition','attachment:filename="+encodeURLComponent("XXXXX")+".xlsx');//设置下载文件命名
    //fs.writeFileSync(path.join(__dirname,'../public/')+name,buffer,{ encoding: 'utf8', mode: 438 /*=0666*/, flag: 'w' })
    //console.log(buffer);
    //ctx.body = buffer;
    ctx.body = {
                code: 200,
                msg:'导出成功',
                data:buffer
                }

}
//找开始时间之后十五分钟内有打卡记录
function findStart(start,startarray){

}
/**返回a，b差的时间 a、b不需要moment a大正数*/
function AdiffB(a,b){
    let duration = moment.duration(moment(a).diff(moment(b),'minute'));
    //let s = `${duration.asHours()}:${moment([2000, 1, 1]).add(duration).format("mm:ss")}`;
    return duration;
}
//数组中在start之前且与start差值最小的
function oneBefore(start,arr,lunchstart,lunchend,toalTime,workstartTime,workendTime){
    //在请假单之前的打卡时间
    let temp= arr.filter(item=>{
        return AdiffB(start,item.checktime)>0?true:false;
    });
    //请假单开始日期的午休开始时间
    let breaks=`${moment(start).format('YYYY-MM-DD')} ${lunchstart}`;
    //请假单开始日期的午休结束时间
    let breake=`${moment(start).format('YYYY-MM-DD')} ${lunchend}`;
    if(temp&&temp.length>0){
        //请假单开始之前有打卡记录
        temp=temp.map(item=>{
            return item['checktime']
        });
        //排序使temp[0]为最靠近请假单开始的记录
        temp.sort(function(a,b){
            return AdiffB(a,b)>0?-1:1;
        })
       
        if(moment(start).isBetween(breaks,breake,'second','[]')){
             //请假单开始在午休之间按午休开始时间算
            start=`${moment(start).format('YYYY-MM-DD')} ${lunchstart}`
            if(moment(temp[0]).isBetween(breaks,breake,'second','[]')){
                //打卡时间在午休
                temp[0]=`${moment(start).format('YYYY-MM-DD')} ${lunchstart}`
            }
        }else if(moment(start).isSameOrAfter(breake)){
                //请假单开始在午休之后
                if(moment(temp[0]).isBetween(breaks,breake,'second','[]')){
                    //打卡时间在午休
                    temp[0]=`${moment(start).format('YYYY-MM-DD')} ${lunchend}`
                }else if(moment(temp[0]).isSameOrBefore(breaks)) {
                    //打卡时间在午休前（抛出午休时间）
                    temp[0]=moment(moment(start).add(`${toalTime}`,'minutes'));
                }
        }
        return  AdiffB(start,temp[0]);
    }else{
        //请假单开始之前没有打卡记录；按正常上班算
        if(moment(start).isBetween(breaks,breake,'second','[]')){
            //如果开始时间在午休之间
            start=breaks;
        }else if(moment(start).isSameOrAfter(breake)){
            //如果开始时间在午休之后 方便计算顺延一个午休时间
            start=moment(moment(start).subtract(`${toalTime}`,'minutes'))
        }
        return  AdiffB(start,`${moment(start).format('YYYY-MM-DD')} ${workstartTime}`);
    }
}
//数组中在endt之后且与end差值最小的
/**
 * 
 * @param {*} end 请假单结束时间
 * @param {Array} arr 与请假单结束是同一天的打卡记录数组
 * @param {*} lunchstart 午休开始时间
 * @param {*} lunchend 午休结束时间
 * @param {*} toalTime 午休总时长
 * @param {*} workstartTime 每天的上时间
 * @param {*} workendTime 每天的下班时间
 */
function oneAfter(end,arr,lunchstart,lunchend,toalTime,workstartTime,workendTime){
    //过滤出请假单之后的打卡时间
    let temp= arr.filter(item=>{
        return AdiffB(end,item.checktime)<0?true:false;
    });
    //请假单结束日期的午休开始时间
    let breaks=`${moment(end).format('YYYY-MM-DD')} ${lunchstart}`;
    //请假单结束日期的午休结束时间
    let breake=`${moment(end).format('YYYY-MM-DD')} ${lunchend}`;
    if(temp&&temp.length>0){
        //请假单之后有打卡记录
        temp=temp.map(item=>{
            return item['checktime']
        });
        temp.sort(function(a,b){
            return AdiffB(a,b)>0?1:-1;
        })
        //01-10 08:05到01-11 10:16请假单开始之前没有打卡记录晚归0分钟
        //请假单结束时间在上午，打卡记录在下午减去午休时间
        if(moment(end).isSameOrBefore(breaks)){
            if(moment(temp[0]).isBetween(breaks,breake,'second','[]')){
                //打卡记录在午休区间；按午休开始时间算
                temp[0]=moment(`${moment(end).format('YYYY-MM-DD')} ${lunchstart}`);
            }else if(moment(temp[0]).isAfter(breake)){
                //打卡记录在午休后，下午跨一个午休区间，结束时间提前一个小时
                temp[0]=moment(moment(end).subtract(`${toalTime}`,'minutes'));
            }
        }
        return AdiffB(temp[0],end);
    }else{
        //如果在请假单结束之后没有打卡记录 按下班时间算
        if(moment(end).isSameOrBefore(breaks)){
            //结束时间在午休之前，减除午休时间（计算方便把结束时间顺延一个午休时间）
            end=moment(moment(end).add(`${toalTime}`,'minutes'));
        }else if(moment(end).isBetween(breaks,breake,'second','[]')){
            //结束时间在午休之间；按午休结束时间
            end=moment(`${moment(end).format('YYYY-MM-DD')} ${lunchend}`);
        }
        //其余正常算
        return AdiffB(`${moment(end).format('YYYY-MM-DD')} ${workendTime}`,end);
    }
    
}

module.exports = checkTimeController